home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Commun⁄Network / Telnet 2.5.src.ThinkC / source / netevent.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-05-19  |  17.3 KB  |  659 lines  |  [TEXT/MPS ]
  1. #ifdef lint
  2. static char *SCCSid = "%W%    (NCSA)    %G%";
  3. #endif
  4. /*
  5. *    netevent.c
  6. *     by Gaige B. Paulsen
  7. ****************************************************************************
  8. *    Part of NCSA Telnet for the Macintosh                                   *
  9. *                                                                          *
  10. *      Uses    :                                                               *
  11. *      TCP/IP kernel for NCSA Telnet                                       *
  12. *      by Tim Krauskopf                                                    *
  13. *       with Macintosh code by Gaige B. Paulsen                                 *
  14. *                                                                          *
  15. *      National Center for Supercomputing Applications                     *
  16. *      152 Computing Applications Building                                 *
  17. *      605 E. Springfield Ave.                                             *
  18. *      Champaign, IL  61820                                                *
  19. *                                                                          *
  20. *                                                                          *
  21. ****************************************************************************
  22. *
  23. *    Network event handler for NCSA Telnet for the Macintosh
  24. *
  25. *    Called by:
  26. *        event.c
  27. *        maclook.c
  28. */
  29.  
  30. /*
  31.  *    Files for inclusion.
  32.  */
  33. #include    <stdio.h>
  34. #include     <string.h>
  35.  
  36. #include    <Dialogs.h>
  37. #include    <Events.h>
  38. #include    <Memory.h>
  39. #include    <Windows.h>
  40. #include    <Menus.h>
  41.  
  42. #include    "hostform.h"
  43. #include    "whatami.h"
  44. #include    "wind.h"
  45. #include "configrec.h"
  46. #include "util.h"
  47. #include "bkgr.h"
  48. #include "maclook.h"
  49. #include "user.h"
  50. #include "menu.h"
  51. #include "tools.h"
  52.  
  53. #include "rsmac.h"
  54. #include "vrrgmac.h"
  55. #include "tekrgmac.h"
  56. #include    "vsdata.h"
  57. #include    "vskeys.h"
  58.  
  59. #include    "Prefs.h"
  60.  
  61. #define HFTP 21                /* BYU mod */
  62.  
  63. #define Conn        5
  64. #define COnext        1
  65. #define OopsDLOG    640
  66. #define PASTELEFT    130        /* UserEvent, PASTELEFT causes pasteText */
  67. #define PASTESIZE    32        /* BYU - Paste in 32 byte chunks to avoid trouble */
  68.  
  69.  
  70. int
  71.     blocksize,        /* how large do we make the blocks when we read? */
  72.     ev,                /* Event type */
  73.     what,            /* What kind of net event */
  74.     dat;            /* The data for the event */
  75.  
  76. extern WindRec
  77.     *screens,                /* The screen array from Maclook */
  78.     ftplog;                    /* The FTP log screen from Maclook */
  79.  
  80. extern unsigned char 
  81.     tempspot[];                /* 256 bytes for temp strings */
  82.  
  83. unsigned char *readspace;    /* main buffer space */
  84.  
  85. extern void DoTheMenuChecks();
  86.  
  87. extern short slip_connection;    /* BYU 2.4.16 */
  88.  
  89. extern int
  90.     MacBinary,                /* MacBinary status from menu.c, for resetting if prefs say so.. */
  91.     ScrlLock,                /* Hey, do we have scroll lock? */
  92.     scrn,                    /* The current screen from Maclook */
  93.     numwindows;                /* The number of windows now from Maclook */
  94. extern void         /* BYU */
  95.     ftpgo(),        /* BYU */
  96.     ftppi(),        /* BYU */
  97.     userftpd();        /* BYU */
  98. char *errmsg,
  99.      *neterrstring();
  100. pascal int
  101.      modalProc();
  102. char ftpname[128];
  103. int portNo;
  104. long ftptime;
  105. #if 0                            /* BYU LSC - was "#ifndef MPW" */
  106. long TickCount();
  107. #endif
  108. extern MenuHandle myMenus[];
  109.  
  110. int FileInTransit;
  111.  
  112. void NetError
  113.   (
  114.     int code
  115.   )
  116. {
  117.     char buffer1[100],buffer2[100], *neterrstring();
  118.     int ev,what,class;
  119.     short dItem;
  120.     DialogPtr dtemp;
  121.  
  122.     buffer1[0]=0;
  123.     buffer2[0]=0;
  124.  
  125.     if (code<0) {
  126.         strncpy( buffer2, neterrstring(code), 99);
  127.         ev = Sgetevent( ERRCLASS,&what,&code);
  128.         if (ev)
  129.             strncpy( buffer1, neterrstring(code), 99);
  130.         }
  131.     else
  132.         strncpy( buffer1, neterrstring(code), 99);
  133.  
  134.     class = code/100;
  135.     if ((class==1 || class==5 || class==9 ) && ( code!=103)) {
  136.         /* Ok, I'll show the user these */
  137. #ifndef MPW
  138.         c2pstr(buffer1);        /* BYU LSC */
  139.         c2pstr(buffer2);        /* BYU LSC */
  140.         ParamText((unsigned char *) buffer1,(unsigned char *) buffer2,"\P ","\P ");    /* BYU LSC */
  141. #else
  142.         ParamText( buffer1,buffer2," "," ");
  143. #endif
  144.         dtemp=GetNewDialog(OopsDLOG,(Ptr) 0L,(WindowPtr) -1L);    /* Put up the error notice */
  145.         ModalDialog((ModalFilterProcPtr) modalProc,&dItem);        /* Get an event */
  146.         DisposDialog(dtemp);            /* Take it off.....all off......*/
  147.         }
  148.     else {
  149.         if (buffer1[0])
  150.             putln(buffer1);
  151.         if (buffer2[0])
  152.             putln(buffer2);
  153.         }
  154.  
  155. }
  156.  
  157. void RangeError
  158.   (
  159.     int i
  160.   )
  161. {
  162.     char temp[20];
  163.  
  164.     sprintf(temp,"%d in %d", -i,numwindows);
  165.     putln(temp);
  166. }
  167.  
  168. int WindByPort
  169.   (
  170.     int port
  171.   )
  172. {
  173.     int i=0;
  174.  
  175.     while (i<numwindows && (screens[i].port!=port || screens[i].active <0)) i++;
  176.  
  177.     if (i>=numwindows) {
  178.         i = 0;                                    /* BYU */
  179.         while ((i<numwindows) &&                 /* BYU */
  180.             ((screens[i].ftpport!=port) ||         /* BYU */
  181.             (screens[i].active <0))) i++;        /* BYU */
  182.         if (i>=numwindows) {                    /* BYU */
  183.             putln("Can't find a window for the port # in WindByPort");    /* BYU */
  184.             RangeError(i);            /* BYU */
  185.             if (i==0) i=999;        /* BYU */
  186.             return(-i);                /* BYU */
  187.             }                        /* BYU */
  188.         }                            /* BYU */
  189.  
  190.     return(i);
  191. }
  192.  
  193. int WindByDom
  194.   (
  195.     int port
  196.   )
  197. {
  198.     int i=0;
  199.  
  200.     while (i<numwindows && (screens[i].port!=port || screens[i].active >=0)) i++;
  201.  
  202.     if (i>=numwindows) {
  203.         if (i==0) i=999;
  204.         putln("CANT FIND THE domPORT SPECIFIED");
  205.         return(-i);
  206.         }
  207.  
  208.     return(i);
  209. }
  210.  
  211. void FlushNetwork
  212.   (
  213.     int scrn
  214.   )
  215. {
  216.     int throwsize,cnt=512;
  217.     
  218.     if (blocksize < 512)
  219.         throwsize = 512;
  220.     else
  221.         throwsize = blocksize;
  222.  
  223.     RSskip(screens[scrn].vs, 1);                /* Don't do any output */
  224.  
  225.     while (cnt>0) {
  226.         cnt = netread(dat,readspace,throwsize);
  227.         parse( &screens[scrn ], readspace, cnt);
  228.         }
  229.  
  230.     RSskip(screens[scrn].vs, 0);                /* Do output now */
  231.     SetPort( screens[scrn].wind);
  232.     InvalRect(&screens[scrn].wind->portRect);    /* Don't forget to redraw */
  233. }
  234.  
  235.  
  236. ftppasteText( scrn)        /* BYU */
  237. int scrn;                /* BYU */
  238. {                        /* BYU */
  239.     char *ascii;        /* BYU */
  240.                         /* BYU */
  241.     ascii = screens[scrn].outptr;                    /* BYU */
  242.     while ((screens[scrn].outlen > 0) &&             /* BYU */
  243.         (*ascii>31) && (*ascii <127)) {                /* BYU */
  244.         parse( &screens[ scrn],(unsigned char *) ascii, 1);        /* BYU LSC */
  245.         screens[scrn].kbbuf[ screens[scrn].kblen++ ] = *ascii;    /* BYU */
  246.         screens[scrn].outlen--;                        /* BYU */
  247.         ascii++;                                    /* BYU */
  248.         }                                            /* BYU */
  249.     screens[scrn].outptr = ascii;                    /* BYU */
  250.     if (*ascii == '\015') {                            /* BYU */
  251.         parse( &screens[scrn],(unsigned char *) "\015\012",2);    /* BYU LSC */
  252.         screens[scrn].kbbuf[ screens[scrn].kblen++ ] = 0;        /* BYU */
  253.         ftppi(screens[scrn].kbbuf);                                /* BYU - ftp client */
  254.         screens[scrn].kblen=0;                                    /* BYU */
  255.         }                                    /* BYU */
  256.     while ((screens[scrn].outlen > 0) &&     /* BYU */
  257.         ((*ascii<=31) || (*ascii >=127))) {    /* BYU */
  258.         screens[scrn].outlen--;                /* BYU */
  259.         screens[scrn].outptr++;                /* BYU */
  260.         }                /* BYU */
  261. }                        /* BYU */
  262.  
  263.  
  264. void pasteText
  265.   (
  266.     int scrn
  267.   )
  268. {
  269.     int amount;
  270.     if (!screens[scrn].outlen)
  271.         return;
  272.  
  273.     if ((screens[scrn].connectionType == 0) || slip_connection) {    /* BYU 2.4.16 */
  274.  
  275.         if (netpush(screens[scrn].port) != 0) {            /* BYU 2.4.16 - wait until not busy */
  276.             netputevent( USERCLASS, PASTELEFT, scrn);    /* BYU 2.4.16 */
  277.             return;                                        /* BYU 2.4.16 */
  278.         }                                                /* BYU 2.4.16 */
  279.         if (screens[scrn].incount) {                    /* BYU 2.4.16 */
  280.             screens[scrn].incount = 0;                    /* BYU 2.4.16 */
  281.             screens[scrn].outcount = 0;                    /* BYU 2.4.16 */
  282.             netputevent( USERCLASS, PASTELEFT, scrn);    /* BYU 2.4.16 */
  283.             return;                                        /* BYU 2.4.16 */
  284.         }                                                /* BYU 2.4.16 */
  285.         if (screens[scrn].outcount < 2) {                /* BYU 2.4.16 */
  286.             screens[scrn].outcount++;                    /* BYU 2.4.16 */
  287.             netputevent( USERCLASS, PASTELEFT, scrn);    /* BYU 2.4.16 */
  288.             return;                                        /* BYU 2.4.16 */
  289.         }
  290.         if (netqlen(screens[scrn].port) > 0) {            /* BYU 2.4.16 - wait until not full */
  291.             netputevent( USERCLASS, PASTELEFT, scrn);    /* BYU 2.4.16 */
  292.             return;                                        /* BYU 2.4.16 */
  293.         }                                                /* BYU 2.4.16 */
  294.  
  295.     }                                                /* BYU 2.4.16 */
  296.  
  297.     if (screens[scrn].ftpstate != 0)                 /* BYU */
  298.         ftppasteText( scrn);                        /* BYU */
  299.     else {                                            /* BYU */
  300. #if 0    /* BYU - can't handle large pastes at the time of this patch. */
  301.         amount = netwrite(  screens[scrn].port,        /* BYU */
  302.                             screens[scrn].outptr,    /* BYU */
  303.                             screens[scrn].outlen);    /* BYU */
  304. #else                                                /* BYU */
  305.         if (PASTESIZE <= screens[scrn].outlen)        /* BYU */
  306.             amount = PASTESIZE;                        /* BYU */
  307.         else                                        /* BYU */
  308.             amount = screens[scrn].outlen;            /* BYU */
  309.         amount = netwrite(  screens[scrn].port,        /* BYU */
  310.                             screens[scrn].outptr,    /* BYU */
  311.                             amount);                /* BYU */
  312. #endif                                                /* BYU */
  313.         if (screens[scrn].echo)                                        /* BYU */
  314.             parse( &screens[scrn],(unsigned char *) screens[scrn].outptr,amount);    /* BYU LSC */
  315.         screens[scrn].outlen -= amount;                                /* BYU */
  316.         screens[scrn].outptr += (long) amount;                        /* BYU */
  317. /*        screens[scrn].outcount += amount;            /* BYU LSC */
  318.         }                                                            /* BYU */
  319.  
  320.     if ( screens[scrn].outlen <=0) {
  321.         screens[scrn].clientflags &= ~PASTE_IN_PROGRESS;    /* BYU LSC */
  322.         HUnlock(screens[scrn].outhand);
  323.         DisposHandle(screens[scrn].outhand);
  324.         screens[scrn].outptr = (char *) 0L;            /* BYU LSC */
  325.         screens[scrn].outhand = (char **) 0L;        /* BYU LSC */
  326.         }
  327.     else
  328.         netputevent( USERCLASS, PASTELEFT, scrn);
  329. }
  330.  
  331. void DoNetEvents
  332.   (
  333.     void
  334.   )
  335.   {
  336.     int i,cnt;
  337.  
  338.     
  339.     ev = Sgetevent(USERCLASS | CONCLASS | ERRCLASS,&what,&dat);
  340.  
  341.     if ( !ev ) {
  342.         if ( (ftptime < TickCount()) && FileInTransit) {
  343.             long pos;
  344.  
  345.             Sftpstat(&pos);                    /* get transfer status */
  346.             if (pos <= 0) 
  347.                 ftpmess("FTP Status: transferring\015\012");
  348.             else {
  349.                 if (FileInTransit+2)
  350.                     sprintf((char *) tempspot,"FTP Status: %ld bytes remaining.\015\012", pos);        /* BYU LSC */
  351.                 else
  352.                     sprintf((char *) tempspot,"FTP Status: %ld bytes transferred.\015\012", pos);    /* BYU LSC */
  353.  
  354.                 ftpmess((char *) tempspot);    /* BYU LSC */
  355.                 }
  356.  
  357.             ftptime=TickCount()+30;            /* 1/2 second intervals */
  358.             }
  359.         return;
  360.         }
  361.  
  362.     switch( what) {
  363.     case ERRCLASS:                            /* Error event */
  364.             NetError(dat);
  365.         break;
  366.  
  367.     case CONCLASS:                            /* Connection type event */
  368.             switch (ev) {
  369.                 case CONOPEN:                /* connection opened or closed */
  370. #ifdef JOHN_DEERE
  371.                 {     extern    int jdp;
  372.                     if (jdp == dat) {
  373.                         netwrite( jdp, "Hello from Macintosh\015\012",22);    /* BYU 2.4.18 - changed \n to \015 */
  374.                         netclose( jdp);
  375.                         jdp = netlisten( 2001,0);        /* BYU 2.4.15 */
  376.                         }
  377.                 }
  378. #endif
  379.                     i=WindByPort(dat);
  380.                     if (i<0) { RangeError(i); return; }
  381. /* BYU mod - This tests TRUE if it is the telnet port or the main ftp port */
  382.                     if (dat == screens[i].port) {        /* BYU - is this Telnet? */
  383.                         screens[ i].active=0;            /* BYU - Mark active */
  384.                         RSshow( screens[i].vs);            /* BYU */
  385.                         SelectWindow(screens[i].wind);    /* BYU */
  386. #if 1                                                    /* BYU 2.4.20 */
  387.                         if (screens[i].ftpstate != 0)     /* BYU 2.4.20 - Only if not FTP */
  388.                             userftpd(CONOPEN,dat);        /* BYU */
  389. #else                                                    /* BYU 2.4.20 */
  390.                         if (screens[i].ftpstate == 0) {    /* BYU - Only if not FTP */
  391.                             netpush(screens[i].port);    /* BYU */
  392.                             netwrite(screens[i].port,"\377\375\001\377\375\003\377\374\43",9); /* BYU - Default telnet parms */
  393.                         } else {                        /* BYU */
  394.                             userftpd(CONOPEN,dat);        /* BYU */
  395.                         }                                /* BYU */
  396. #endif                                                    /* BYU 2.4.20 */
  397.                         screens[i].Usga=1;        /* BYU */
  398.                         changeport(scrn,i);        /* BYU */
  399.                         liveport(scrn);            /* BYU */
  400.                         DoTheMenuChecks();        /* BYU */
  401.                     } else {                    /* BYU - not Telnet so must be FTP */
  402.                       userftpd(CONOPEN,dat);    /* BYU */
  403.                     }                            /* BYU */
  404.                     break;
  405.  
  406.                 case CONDATA:                /* data arrived for me */
  407.                     i=WindByPort(dat);                                    /* BYU */
  408.                     if (i<0) { RangeError(i); return; }                    /* BYU */
  409.                     if (ScrlLock || !screens[i].enabled)    /* BYU LSC */
  410.                         netputuev( CONCLASS, CONDATA, dat);
  411.                     else {
  412.                         if (screens[i].ftpstate == 0) {                /* BYU LSC */
  413.                             cnt = netread(dat,readspace,blocksize);    /* BYU LSC */
  414.                             parse( &screens[i], readspace, cnt);    /* BYU LSC */
  415.                             screens[i].incount += cnt;                /* BYU LSC */
  416.                             }                            /* BYU */
  417.                         else {                            /* BYU */
  418.                             userftpd(CONDATA,dat);        /* BYU */
  419.                             }                            /* BYU */
  420.                         }
  421.                     break;
  422.  
  423.                 case CONFAIL:
  424.                     {
  425.                         int i;
  426.                         netclose( dat);
  427.                         i= WindByPort(dat);
  428.                         if (i<0) { RangeError(i); return; }
  429. #ifndef MPW
  430.                         c2pstr(screens[i].machine);            /* BYU LSC */
  431.                         OtherError((char *) "\PHost or gateway not responding:",    /* BYU LSC */
  432.                                     screens[i].machine);
  433.                         p2cstr(screens[i].machine);            /* BYU LSC */
  434. #else
  435.                         OtherError( "Host or gateway not responding:",
  436.                                     screens[i].machine);
  437. #endif MPW
  438.                         destroyport( i);
  439.                     }
  440.                     break;
  441.  
  442.                 case CONCLOSE:
  443.                     {
  444.                         int i;
  445.  
  446.                         i= WindByPort(dat);
  447.                         if (i<0) { 
  448.                             netclose( dat);            /* We close again.... */
  449.                             RangeError(i);
  450.                             return;
  451.                             }
  452. /* BYU - This tests TRUE if it is the telnet port or the main ftp port */
  453.                         if (dat == screens[i].port) {        /* BYU */
  454.                             putln("Closing....");            /* BYU */
  455.                             FlushNetwork(i);                /* BYU */
  456.                             netclose( screens[i].port);        /* BYU */
  457.                             removeport(i);                    /* BYU */
  458.                             }                                /* BYU */
  459.                         else {                                /* BYU */
  460.                             userftpd(CONCLOSE,dat);            /* BYU */
  461.                             }                                /* BYU */
  462.                     }
  463.                     break;
  464.  
  465.                 default:
  466.                     break;
  467.                 }
  468.         break;
  469.  
  470.     case USERCLASS:
  471.             switch (ev) {
  472.                 case DOMOK:                                            /* domain worked */
  473.                     {
  474.                         struct machinfo *mp;
  475.                         int i;
  476.                         
  477.                         i  = WindByDom( dat);
  478.                         if (i<0) { RangeError(i); return; }
  479.                         mp = Slooknum( dat);                        /* get machine info */
  480.                         if (screens[i].ftpstate != 0)                     /* BYU - ftp client */
  481.                             screens[ i].port  = Snetopen(mp,HFTP,0);    /* BYU 2.4.15 - open to host name */
  482.                         else                                             /* BYU */
  483.                             screens[ i].port  = Snetopen(mp,mp->port,0);/* BYU 2.4.15 - open to host name */
  484.                         if (screens[i].port <0) {                    /* Handle Snetopen fail */
  485.                             destroyport( i);
  486.                             }
  487.                         screens[i].active = 1;                        /* Change real status */
  488.                         opnport( i);                                /* Change status mark */
  489.                     }
  490.                     break;
  491.                 case DOMFAIL:    /* domain failed */
  492.                     {
  493.                         i= WindByDom(dat);
  494.                         if (i<0) { RangeError(i); return; }
  495. #ifndef MPW
  496.                         c2pstr(screens[i].machine);            /* BYU LSC */
  497.                         OtherError((char *) "\PHost not in hosts file or on server:",    /* BYU LSC */
  498.                                     screens[i].machine);
  499.                         p2cstr(screens[i].machine);            /* BYU LSC */
  500. #else
  501.                         OtherError( "Host not in hosts file or on server:",
  502.                                     screens[i].machine);
  503. #endif MPW
  504.                         destroyport( i);
  505.                     }
  506.                     break;
  507.                 case FTPBEGIN:
  508.                     Sftpname(ftpname);            /* get name */
  509. /*                    ftpmess("\015\012FTP transferring: "); */
  510. /*                    ftpmess(ftpname); */
  511. /*                    ftpmess("\015\012"); */
  512.                     FileInTransit=dat;
  513.                     ftptime=TickCount();
  514.                     break;
  515.                 case FTPLIST:
  516.                     ftpmess("FTP Directory being Sent\015\012");
  517.                     break;
  518.                 case FTPEND:
  519.                     
  520.             /*        if (!(FileInTransit+2))        
  521.                         ftpmess("\015\012");       */
  522.                     ftpmess("FTP Transfer Concluding\015\012");
  523.                     ftpmess("\015\012");
  524.                     FileInTransit=0;
  525.                     break;
  526.                 case FTPCOPEN:
  527.                     {
  528.                         struct machinfo *mp;
  529.                         unsigned char ftpinfo[8];
  530.                         
  531.                         if (Prefs.MacBReset) 
  532.                             MacBinary = Prefs.MacBinary;
  533.                         updateMenuChecks();
  534.                         xferstart();
  535.                         ftpmess("-----------------------------------------------------------------------------\015\012");
  536.                         ftpmess("FTP server initiated from host: ");
  537.                         Sftphost((char *) ftpinfo);            /* BYU LSC */
  538.  
  539.                         if ((NULL == (mp = Slookip(ftpinfo))) || (NULL == mp->sname)) 
  540.                             sprintf((char *) &tempspot[4],"%d.%d.%d.%d\015\012",    /* BYU LSC */
  541.                                     (int)ftpinfo[0],(int)ftpinfo[1],
  542.                                     (int)ftpinfo[2],(int)ftpinfo[3]);
  543.                         else
  544.                             sprintf((char *) &tempspot[4],"%s\015\012",mp->sname);    /* BYU LSC */
  545.                         ftpmess((char *) &tempspot[4]);        /* BYU LSC */
  546.                     }
  547.                     break;
  548.                 case FTPCLOSE:
  549.                     xferdone();
  550.                     if (Prefs.MacBReset) 
  551.                         MacBinary = Prefs.MacBinary;
  552.                     updateMenuChecks();
  553.                     ftpmess("FTP server ending session\015\012");
  554.                     ftpmess("-----------------------------------------------------------------------------\015\012");
  555.                     ftpmess("\015\012");
  556.  
  557.                     break;
  558.                 case FTPUSER:
  559.                     ftpmess("FTP user ");
  560.                     Sftpuser((char *) tempspot);        /* BYU LSC */
  561.                     ftpmess((char *) tempspot);            /* BYU LSC */
  562.                     ftpmess(" logging in\015\012");
  563.                     break;
  564.                     
  565.                 case FTPPWOK:
  566.                     ftpmess("FTP password OK - logged in\015\012");
  567.                     break;
  568.                 case FTPPWNO:
  569.                     ftpmess("FTP password failed - access denied\015\012");
  570.                     break;
  571.  
  572.                 case 128:            /* RGredraw event */
  573.                     if (VGalive(dat) && RGsupdate(dat))
  574.                         TekEnable(dat);
  575.                     break;
  576.                 case PASTELEFT:
  577.                     pasteText(dat);
  578.                     break;
  579.                 default:
  580.                     break;
  581.             }
  582.         break;
  583.     default:
  584.         break;
  585.         }
  586.   } /* DoNetEvents */
  587.  
  588. void OtherError
  589.   (
  590.     char *mess1,
  591.     char *mess2
  592.   )
  593. {
  594.     char buffer1[100],buffer2[100];
  595.     short dItem;
  596.     DialogPtr dtemp;
  597.  
  598.     buffer1[0]=0;
  599.     buffer2[0]=0;
  600.  
  601.     strncpy(buffer1, mess1, 99);
  602.     strncpy(buffer2, mess2, 99);
  603.  
  604. #ifndef MPW
  605.     ParamText( buffer1,buffer2,"\P ","\P ");
  606. #else
  607.     ParamText( buffer1,buffer2,"P ","P ");
  608. #endif MPW
  609.  
  610.     dtemp=GetNewDialog(OopsDLOG,(Ptr) 0L,(WindowPtr) -1L);    /* Put up the error notice */
  611.     ModalDialog((ModalFilterProcPtr) modalProc,&dItem);        /* Get an event */
  612.     DisposDialog(dtemp);            /* Take it off.....all off......*/
  613. }
  614.  
  615. void ShowAllErrors
  616.   (
  617.     void
  618.   )
  619.   {
  620.     int ev=1, what, dat;
  621.  
  622.     while (ev)
  623.       {
  624.         ev = Sgetevent( ERRCLASS,&what,&dat);
  625.         if (ev)
  626.             NetError(dat);
  627.       }
  628.   }
  629.  
  630. /*****************************************************************************/
  631. /*  setblocksize()
  632. *  Make sure that we have space for the block of data that is to be read each
  633. *  time the netread() is called.
  634. */
  635. int setblocksize
  636.   (
  637.     int tosize
  638.   )
  639. {
  640.  
  641.     blocksize = tosize;                            /* keep size of block */
  642.     
  643.     if (tosize < 512)                            /* minimum buffer */
  644.         tosize = 512;
  645.  
  646.     if (readspace)
  647.         DisposPtr(readspace);                        /* free old block */
  648.         
  649.     if (NULL == (readspace = (unsigned char *) NewPtr(tosize + 100)))    /* BYU LSC */
  650.         return(-1);
  651.  
  652.     return(0);
  653. }
  654.  
  655.  
  656.  
  657.  
  658.  
  659.